home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / WINDOWS / LENGINE.ZIP / MATH3D.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-10  |  5.8 KB  |  218 lines
  1. #include "header.h"
  2.  
  3. extern WORLD *World;
  4.  
  5. MATRIX::MATRIX()
  6. {
  7.     Identity();
  8. };
  9.  
  10. //Maybe optimize memset function
  11. int MATRIX::Identity()
  12. {
  13.     memset(MMat, 0, sizeof(float) * 15);
  14.     MMat[0][0] = MMat[1][1] = MMat[2][2] = MMat[3][3] = 1.0;
  15.     return 0;
  16. };
  17.  
  18. //Definitely needs to be optimized, maybe assembly
  19. void MATRIX::Multiply(float *ptr1, float *ptr2, float *ptr3)
  20. {
  21.     int    i, j, t;
  22.     
  23.     for(i = 0; i < 4; i++)
  24.     {
  25.         for(j = 0; j < 4; j++)
  26.         {
  27.             *(ptr1 + (i << 2) + j) = 0;
  28.             for(t = 0; t < 4; t++)
  29.             {
  30.                 *(ptr1 + (i << 2) + j) +=
  31.                 *(ptr2 + (i << 2) + t) *
  32.                 *(ptr3 + (t << 2) + j);
  33.             }
  34.         }
  35.     }
  36. };
  37.  
  38. void MATRIX::Copy(float *dest, float *src)
  39. {
  40.     memcpy(dest, src, sizeof(float) * 16);
  41. };
  42.  
  43. int MATRIX::Scale(float sx, float sy, float sz)
  44. {
  45.     MMat[0][0] = sx; MMat[1][2] = sy;
  46.     MMat[2][2] = sz; MMat[3][3] = 1.0;
  47.     return 0;
  48. };
  49.  
  50. int MATRIX::Rotate(float x, float y, float z)
  51. {
  52.         float cval, sval;
  53.  
  54.         cval = cos(y); sval = sin(y);
  55.         memset(UMat, 0, sizeof(float) * 15);
  56.         UMat[0][0] = cval; UMat[0][2] = -sval;
  57.         UMat[1][1] = 1.0; UMat[2][0] = sval;
  58.         UMat[2][2] = cval; UMat[3][3] = 1.0;
  59.         Multiply(&TMat[0][0], &MMat[0][0], &UMat[0][0]);
  60.         Copy(&MMat[0][0], &TMat[0][0]);
  61.  
  62.         cval = cos(x); sval = sin(x);
  63.         memset(UMat, 0, sizeof(float) * 15);
  64.         UMat[0][0] = 1.0; UMat[1][1] = cval;
  65.         UMat[1][2] = sval; UMat[2][1] = -sval;
  66.         UMat[2][2] = cval; UMat[3][3] = 1.0;
  67.         Multiply(&TMat[0][0], &MMat[0][0], &UMat[0][0]);
  68.         Copy(&MMat[0][0], &TMat[0][0]);
  69.  
  70.         cval = cos(z); sval = sin(z);
  71.         memset(UMat, 0, sizeof(float) * 15);
  72.         UMat[0][0] = cval; UMat[0][1] = sval;
  73.         UMat[1][0] = -sval; UMat[1][1] = cval;
  74.         UMat[2][2] = 1.0; UMat[3][3] = 1.0;
  75.         Multiply(&TMat[0][0], &MMat[0][0], &UMat[0][0]);
  76.         Copy(&MMat[0][0], &TMat[0][0]);
  77.         return 0;
  78. };
  79.  
  80. int MATRIX::Translate(float xt, float yt, float zt)
  81. {
  82.         memset(UMat, 0, sizeof(float) * 15);
  83.         UMat[0][0] = UMat[1][1] = UMat[2][2] = UMat[3][3] = 1.0;
  84.         UMat[3][0] = xt; UMat[3][1] = yt; UMat[3][2] = zt;
  85.         Multiply(&TMat[0][0], &MMat[0][0], &UMat[0][0]);
  86.         Copy(&MMat[0][0], &TMat[0][0]);
  87.         return 0;
  88. };
  89.  
  90. int MATRIX::TransformWithCamera(LANDSCAPE *land)
  91. {
  92.     UINT v, w;
  93.     VERTEX *vptr;
  94.     int sx, ex;
  95.     int sz, ez;
  96.         
  97.     sx = World->Camera[World->Current_Camera].xTrans;
  98.     sz = World->Camera[World->Current_Camera].zTrans;
  99.     sx >>= 10; sz >>= 10;
  100.     ex = ( ((sx + X_DIR) < land->Width) ? (sx + X_DIR) : (land->Width - 1));
  101.     sx = ( ((sx - X_DIR) < 0) ? (0) : (sx - X_DIR));
  102.     ez = ( ((sz + Z_DIR) < land->Height) ? (sz + Z_DIR) : (land->Height - 1));
  103.     sz = ( ((sz - Z_DIR) < 0) ? (0) : (sz - Z_DIR));
  104.  
  105.     for(v = sx; v < ex; v++)
  106.     {
  107.         for(w = sz; w < ez; w++)
  108.         {
  109.             vptr = &land->Vertex[(w << 8) + v];
  110.  
  111.             vptr->vx = (vptr->ox * MMat[0][0]) +
  112.                        (vptr->oy * MMat[1][0]) +
  113.                        (vptr->oz * MMat[2][0]) +
  114.                                    MMat[3][0];
  115.  
  116.             vptr->vy = (vptr->ox * MMat[0][1]) +
  117.                        (vptr->oy * MMat[1][1]) +
  118.                        (vptr->oz * MMat[2][1]) +
  119.                                    MMat[3][1];
  120.  
  121.             vptr->vz = (vptr->ox * MMat[0][2]) +
  122.                        (vptr->oy * MMat[1][2]) +
  123.                        (vptr->oz * MMat[2][2]) +
  124.                                    MMat[3][2];
  125.         }
  126.     }
  127.     return 0;
  128. };
  129.  
  130. int MATRIX::TransformWithCamera(BITMAPOBJ *bobj)
  131. {
  132.     UINT   v;
  133.     VERTEX *vptr;
  134.  
  135.     for(v = 0; v < 4; v++)
  136.     {
  137.         vptr = &bobj->Vertex[v];
  138.         vptr->vx = (vptr->ox * MMat[0][0]) +
  139.                    (vptr->oy * MMat[1][0]) +
  140.                    (vptr->oz * MMat[2][0]) +
  141.                                MMat[3][0];
  142.  
  143.         vptr->vy = (vptr->ox * MMat[0][1]) +
  144.                    (vptr->oy * MMat[1][1]) +
  145.                    (vptr->oz * MMat[2][1]) +
  146.                                MMat[3][1];
  147.  
  148.         vptr->vz = (vptr->ox * MMat[0][2]) +
  149.                    (vptr->oy * MMat[1][2]) +
  150.                    (vptr->oz * MMat[2][2]) +
  151.                                MMat[3][2];
  152.     }
  153.     return 0;
  154. };
  155.  
  156. int MATRIX::FixBObject(BITMAPOBJ *bobj)
  157. {
  158.     UINT   v;
  159.     VERTEX *vptr;
  160.     for(v = 0; v < 4; v++)
  161.     {
  162.         vptr = &bobj->Vertex[v];
  163.         vptr->vx = (vptr->ox * MMat[0][0]) +
  164.                    (vptr->oy * MMat[1][0]) +
  165.                    (vptr->oz * MMat[2][0]) +
  166.                                MMat[3][0];
  167.  
  168.         vptr->vy = (vptr->ox * MMat[0][1]) +
  169.                    (vptr->oy * MMat[1][1]) +
  170.                    (vptr->oz * MMat[2][1]) +
  171.                                MMat[3][1];
  172.  
  173.         vptr->vz = (vptr->ox * MMat[0][2]) +
  174.                    (vptr->oy * MMat[1][2]) +
  175.                    (vptr->oz * MMat[2][2]) +
  176.                                MMat[3][2];
  177.     }
  178.     return 0;
  179. };
  180.  
  181. float operator%(VECTOR Vector1, VECTOR Vector2)
  182. {
  183.     return((Vector1.x * Vector2.x) +
  184.            (Vector1.y * Vector2.y) +
  185.            (Vector1.z * Vector2.z));
  186. };
  187.  
  188. VECTOR operator^(VECTOR Vector1, VECTOR Vector2)
  189. {
  190.     VECTOR Resultant;
  191.  
  192.     Resultant.x = ( (Vector1.y * Vector2.z) - (Vector1.z * Vector2.y) );
  193.     Resultant.y = ( (Vector1.z * Vector2.x) - (Vector1.x * Vector2.z) );
  194.     Resultant.z = ( (Vector1.x * Vector2.y) - (Vector1.y * Vector2.x) );
  195.  
  196.     return Resultant;
  197. };
  198.  
  199. void VectorLength(VECTOR *Vect)
  200. {
  201.     Vect->Length = sqrt((Vect->x * Vect->x)
  202.                       + (Vect->y * Vect->y)
  203.                       + (Vect->z * Vect->z));
  204. };
  205.  
  206. void Normalize(VECTOR *Vect)
  207. {
  208.     float Temp;
  209.  
  210.     Vect->Length = sqrt((Vect->x * Vect->x)
  211.                       + (Vect->y * Vect->y)
  212.                       + (Vect->z * Vect->z));
  213.     if(Vect->Length != 0.0)
  214.         Temp = 1.0 / Vect->Length;
  215.     Vect->x *= Temp; Vect->y *= Temp; Vect->z *= Temp;
  216. };
  217.  
  218.